// $ANTLR 3.4 C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g 2012-03-25 21:34:44

	package data.analysis.grammar;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class LocStatParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "COND", "COND_DEFAULT", "COND_OP", "COUNT", "DEFINE", "ESC_SEQ", "EXACTLY_ONE", "FRACTION", "HEX_DIGIT", "ID", "MEAN", "MEDIAN", "NOT", "OCTAL_ESC", "ONE_OR_MORE", "SCOPE_OP", "SCRIPT", "STRING", "SUBJECT", "UNICODE_ESC", "WS", "'('", "')'", "','", "';'", "'{'", "'}'"
    };

    public static final int EOF=-1;
    public static final int T__25=25;
    public static final int T__26=26;
    public static final int T__27=27;
    public static final int T__28=28;
    public static final int T__29=29;
    public static final int T__30=30;
    public static final int COND=4;
    public static final int COND_DEFAULT=5;
    public static final int COND_OP=6;
    public static final int COUNT=7;
    public static final int DEFINE=8;
    public static final int ESC_SEQ=9;
    public static final int EXACTLY_ONE=10;
    public static final int FRACTION=11;
    public static final int HEX_DIGIT=12;
    public static final int ID=13;
    public static final int MEAN=14;
    public static final int MEDIAN=15;
    public static final int NOT=16;
    public static final int OCTAL_ESC=17;
    public static final int ONE_OR_MORE=18;
    public static final int SCOPE_OP=19;
    public static final int SCRIPT=20;
    public static final int STRING=21;
    public static final int SUBJECT=22;
    public static final int UNICODE_ESC=23;
    public static final int WS=24;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public LocStatParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public LocStatParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
        this.state.ruleMemo = new HashMap[18+1];
         

    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return LocStatParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g"; }


    public static class start_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "start"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:72:1: start : ( stat )+ EOF ;
    public final LocStatParser.start_return start() throws RecognitionException {
        LocStatParser.start_return retval = new LocStatParser.start_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token EOF2=null;
        LocStatParser.stat_return stat1 =null;


        LocStatAST EOF2_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:73:2: ( ( stat )+ EOF )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:73:4: ( stat )+ EOF
            {
            root_0 = (LocStatAST)adaptor.nil();


            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:73:4: ( stat )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==STRING) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:73:4: stat
            	    {
            	    pushFollow(FOLLOW_stat_in_start460);
            	    stat1=stat();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, stat1.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_start463); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            EOF2_tree = 
            (LocStatAST)adaptor.create(EOF2)
            ;
            adaptor.addChild(root_0, EOF2_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "start"


    public static class stat_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "stat"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:1: stat : STRING DEFINE ^ ( count | fraction | mean | med ) ';' !;
    public final LocStatParser.stat_return stat() throws RecognitionException {
        LocStatParser.stat_return retval = new LocStatParser.stat_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token STRING3=null;
        Token DEFINE4=null;
        Token char_literal9=null;
        LocStatParser.count_return count5 =null;

        LocStatParser.fraction_return fraction6 =null;

        LocStatParser.mean_return mean7 =null;

        LocStatParser.med_return med8 =null;


        LocStatAST STRING3_tree=null;
        LocStatAST DEFINE4_tree=null;
        LocStatAST char_literal9_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:5: ( STRING DEFINE ^ ( count | fraction | mean | med ) ';' !)
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:7: STRING DEFINE ^ ( count | fraction | mean | med ) ';' !
            {
            root_0 = (LocStatAST)adaptor.nil();


            STRING3=(Token)match(input,STRING,FOLLOW_STRING_in_stat473); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            STRING3_tree = 
            (LocStatAST)adaptor.create(STRING3)
            ;
            adaptor.addChild(root_0, STRING3_tree);
            }

            DEFINE4=(Token)match(input,DEFINE,FOLLOW_DEFINE_in_stat475); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            DEFINE4_tree = 
            (LocStatAST)adaptor.create(DEFINE4)
            ;
            root_0 = (LocStatAST)adaptor.becomeRoot(DEFINE4_tree, root_0);
            }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:22: ( count | fraction | mean | med )
            int alt2=4;
            switch ( input.LA(1) ) {
            case COUNT:
                {
                alt2=1;
                }
                break;
            case FRACTION:
                {
                alt2=2;
                }
                break;
            case MEAN:
                {
                alt2=3;
                }
                break;
            case MEDIAN:
                {
                alt2=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;

            }

            switch (alt2) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:23: count
                    {
                    pushFollow(FOLLOW_count_in_stat479);
                    count5=count();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, count5.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:29: fraction
                    {
                    pushFollow(FOLLOW_fraction_in_stat481);
                    fraction6=fraction();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, fraction6.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:38: mean
                    {
                    pushFollow(FOLLOW_mean_in_stat483);
                    mean7=mean();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, mean7.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:76:43: med
                    {
                    pushFollow(FOLLOW_med_in_stat485);
                    med8=med();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, med8.getTree());

                    }
                    break;

            }


            char_literal9=(Token)match(input,28,FOLLOW_28_in_stat488); if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "stat"


    public static class count_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "count"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:79:1: count : COUNT '(' subj ')' -> ^( COUNT subj ) ;
    public final LocStatParser.count_return count() throws RecognitionException {
        LocStatParser.count_return retval = new LocStatParser.count_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token COUNT10=null;
        Token char_literal11=null;
        Token char_literal13=null;
        LocStatParser.subj_return subj12 =null;


        LocStatAST COUNT10_tree=null;
        LocStatAST char_literal11_tree=null;
        LocStatAST char_literal13_tree=null;
        RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleSubtreeStream stream_subj=new RewriteRuleSubtreeStream(adaptor,"rule subj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:80:2: ( COUNT '(' subj ')' -> ^( COUNT subj ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:80:4: COUNT '(' subj ')'
            {
            COUNT10=(Token)match(input,COUNT,FOLLOW_COUNT_in_count501); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_COUNT.add(COUNT10);


            char_literal11=(Token)match(input,25,FOLLOW_25_in_count503); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_25.add(char_literal11);


            pushFollow(FOLLOW_subj_in_count505);
            subj12=subj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_subj.add(subj12.getTree());

            char_literal13=(Token)match(input,26,FOLLOW_26_in_count507); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_26.add(char_literal13);


            // AST REWRITE
            // elements: subj, COUNT
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocStatAST)adaptor.nil();
            // 80:23: -> ^( COUNT subj )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:80:26: ^( COUNT subj )
                {
                LocStatAST root_1 = (LocStatAST)adaptor.nil();
                root_1 = (LocStatAST)adaptor.becomeRoot(
                stream_COUNT.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_subj.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "count"


    public static class fraction_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "fraction"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:83:1: fraction : FRACTION '(' a= subj ',' b= subj ')' -> ^( FRACTION $a $b) ;
    public final LocStatParser.fraction_return fraction() throws RecognitionException {
        LocStatParser.fraction_return retval = new LocStatParser.fraction_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token FRACTION14=null;
        Token char_literal15=null;
        Token char_literal16=null;
        Token char_literal17=null;
        LocStatParser.subj_return a =null;

        LocStatParser.subj_return b =null;


        LocStatAST FRACTION14_tree=null;
        LocStatAST char_literal15_tree=null;
        LocStatAST char_literal16_tree=null;
        LocStatAST char_literal17_tree=null;
        RewriteRuleTokenStream stream_FRACTION=new RewriteRuleTokenStream(adaptor,"token FRACTION");
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleTokenStream stream_27=new RewriteRuleTokenStream(adaptor,"token 27");
        RewriteRuleSubtreeStream stream_subj=new RewriteRuleSubtreeStream(adaptor,"rule subj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:84:2: ( FRACTION '(' a= subj ',' b= subj ')' -> ^( FRACTION $a $b) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:84:4: FRACTION '(' a= subj ',' b= subj ')'
            {
            FRACTION14=(Token)match(input,FRACTION,FOLLOW_FRACTION_in_fraction527); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_FRACTION.add(FRACTION14);


            char_literal15=(Token)match(input,25,FOLLOW_25_in_fraction529); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_25.add(char_literal15);


            pushFollow(FOLLOW_subj_in_fraction533);
            a=subj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_subj.add(a.getTree());

            char_literal16=(Token)match(input,27,FOLLOW_27_in_fraction535); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_27.add(char_literal16);


            pushFollow(FOLLOW_subj_in_fraction539);
            b=subj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_subj.add(b.getTree());

            char_literal17=(Token)match(input,26,FOLLOW_26_in_fraction541); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_26.add(char_literal17);


            // AST REWRITE
            // elements: b, FRACTION, a
            // token labels: 
            // rule labels: retval, b, a
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);
            RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);

            root_0 = (LocStatAST)adaptor.nil();
            // 84:39: -> ^( FRACTION $a $b)
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:84:42: ^( FRACTION $a $b)
                {
                LocStatAST root_1 = (LocStatAST)adaptor.nil();
                root_1 = (LocStatAST)adaptor.becomeRoot(
                stream_FRACTION.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_a.nextTree());

                adaptor.addChild(root_1, stream_b.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "fraction"


    public static class mean_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "mean"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:87:1: mean : MEAN '(' scopedSubj ')' -> ^( MEAN scopedSubj ) ;
    public final LocStatParser.mean_return mean() throws RecognitionException {
        LocStatParser.mean_return retval = new LocStatParser.mean_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token MEAN18=null;
        Token char_literal19=null;
        Token char_literal21=null;
        LocStatParser.scopedSubj_return scopedSubj20 =null;


        LocStatAST MEAN18_tree=null;
        LocStatAST char_literal19_tree=null;
        LocStatAST char_literal21_tree=null;
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_MEAN=new RewriteRuleTokenStream(adaptor,"token MEAN");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleSubtreeStream stream_scopedSubj=new RewriteRuleSubtreeStream(adaptor,"rule scopedSubj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:87:5: ( MEAN '(' scopedSubj ')' -> ^( MEAN scopedSubj ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:87:7: MEAN '(' scopedSubj ')'
            {
            MEAN18=(Token)match(input,MEAN,FOLLOW_MEAN_in_mean563); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_MEAN.add(MEAN18);


            char_literal19=(Token)match(input,25,FOLLOW_25_in_mean565); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_25.add(char_literal19);


            pushFollow(FOLLOW_scopedSubj_in_mean567);
            scopedSubj20=scopedSubj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_scopedSubj.add(scopedSubj20.getTree());

            char_literal21=(Token)match(input,26,FOLLOW_26_in_mean569); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_26.add(char_literal21);


            // AST REWRITE
            // elements: MEAN, scopedSubj
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocStatAST)adaptor.nil();
            // 87:31: -> ^( MEAN scopedSubj )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:87:34: ^( MEAN scopedSubj )
                {
                LocStatAST root_1 = (LocStatAST)adaptor.nil();
                root_1 = (LocStatAST)adaptor.becomeRoot(
                stream_MEAN.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_scopedSubj.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "mean"


    public static class med_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "med"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:90:1: med : MEDIAN '(' scopedSubj ')' -> ^( MEDIAN scopedSubj ) ;
    public final LocStatParser.med_return med() throws RecognitionException {
        LocStatParser.med_return retval = new LocStatParser.med_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token MEDIAN22=null;
        Token char_literal23=null;
        Token char_literal25=null;
        LocStatParser.scopedSubj_return scopedSubj24 =null;


        LocStatAST MEDIAN22_tree=null;
        LocStatAST char_literal23_tree=null;
        LocStatAST char_literal25_tree=null;
        RewriteRuleTokenStream stream_MEDIAN=new RewriteRuleTokenStream(adaptor,"token MEDIAN");
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleSubtreeStream stream_scopedSubj=new RewriteRuleSubtreeStream(adaptor,"rule scopedSubj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:90:5: ( MEDIAN '(' scopedSubj ')' -> ^( MEDIAN scopedSubj ) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:90:7: MEDIAN '(' scopedSubj ')'
            {
            MEDIAN22=(Token)match(input,MEDIAN,FOLLOW_MEDIAN_in_med588); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_MEDIAN.add(MEDIAN22);


            char_literal23=(Token)match(input,25,FOLLOW_25_in_med590); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_25.add(char_literal23);


            pushFollow(FOLLOW_scopedSubj_in_med592);
            scopedSubj24=scopedSubj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_scopedSubj.add(scopedSubj24.getTree());

            char_literal25=(Token)match(input,26,FOLLOW_26_in_med594); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_26.add(char_literal25);


            // AST REWRITE
            // elements: MEDIAN, scopedSubj
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (LocStatAST)adaptor.nil();
            // 90:33: -> ^( MEDIAN scopedSubj )
            {
                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:90:36: ^( MEDIAN scopedSubj )
                {
                LocStatAST root_1 = (LocStatAST)adaptor.nil();
                root_1 = (LocStatAST)adaptor.becomeRoot(
                stream_MEDIAN.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_scopedSubj.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "med"


    public static class scopedSubj_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "scopedSubj"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:93:1: scopedSubj : a= subj SCOPE_OP b= subj -> $a ^( SCOPE_OP $b) ;
    public final LocStatParser.scopedSubj_return scopedSubj() throws RecognitionException {
        LocStatParser.scopedSubj_return retval = new LocStatParser.scopedSubj_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token SCOPE_OP26=null;
        LocStatParser.subj_return a =null;

        LocStatParser.subj_return b =null;


        LocStatAST SCOPE_OP26_tree=null;
        RewriteRuleTokenStream stream_SCOPE_OP=new RewriteRuleTokenStream(adaptor,"token SCOPE_OP");
        RewriteRuleSubtreeStream stream_subj=new RewriteRuleSubtreeStream(adaptor,"rule subj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:94:2: (a= subj SCOPE_OP b= subj -> $a ^( SCOPE_OP $b) )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:94:4: a= subj SCOPE_OP b= subj
            {
            pushFollow(FOLLOW_subj_in_scopedSubj616);
            a=subj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_subj.add(a.getTree());

            SCOPE_OP26=(Token)match(input,SCOPE_OP,FOLLOW_SCOPE_OP_in_scopedSubj618); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_SCOPE_OP.add(SCOPE_OP26);


            pushFollow(FOLLOW_subj_in_scopedSubj622);
            b=subj();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_subj.add(b.getTree());

            // AST REWRITE
            // elements: SCOPE_OP, b, a
            // token labels: 
            // rule labels: retval, b, a
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);
            RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);

            root_0 = (LocStatAST)adaptor.nil();
            // 94:27: -> $a ^( SCOPE_OP $b)
            {
                adaptor.addChild(root_0, stream_a.nextTree());

                // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:94:33: ^( SCOPE_OP $b)
                {
                LocStatAST root_1 = (LocStatAST)adaptor.nil();
                root_1 = (LocStatAST)adaptor.becomeRoot(
                stream_SCOPE_OP.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_b.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "scopedSubj"


    public static class subj_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "subj"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:1: subj : ( ID ( COND_OP condArgs )? -> ^( SUBJECT ID ( condArgs )? ) | '(' subj ')' -> subj );
    public final LocStatParser.subj_return subj() throws RecognitionException {
        LocStatParser.subj_return retval = new LocStatParser.subj_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token ID27=null;
        Token COND_OP28=null;
        Token char_literal30=null;
        Token char_literal32=null;
        LocStatParser.condArgs_return condArgs29 =null;

        LocStatParser.subj_return subj31 =null;


        LocStatAST ID27_tree=null;
        LocStatAST COND_OP28_tree=null;
        LocStatAST char_literal30_tree=null;
        LocStatAST char_literal32_tree=null;
        RewriteRuleTokenStream stream_COND_OP=new RewriteRuleTokenStream(adaptor,"token COND_OP");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleSubtreeStream stream_condArgs=new RewriteRuleSubtreeStream(adaptor,"rule condArgs");
        RewriteRuleSubtreeStream stream_subj=new RewriteRuleSubtreeStream(adaptor,"rule subj");
        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:5: ( ID ( COND_OP condArgs )? -> ^( SUBJECT ID ( condArgs )? ) | '(' subj ')' -> subj )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==ID) ) {
                alt4=1;
            }
            else if ( (LA4_0==25) ) {
                alt4=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;

            }
            switch (alt4) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:7: ID ( COND_OP condArgs )?
                    {
                    ID27=(Token)match(input,ID,FOLLOW_ID_in_subj644); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ID.add(ID27);


                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:10: ( COND_OP condArgs )?
                    int alt3=2;
                    int LA3_0 = input.LA(1);

                    if ( (LA3_0==COND_OP) ) {
                        alt3=1;
                    }
                    switch (alt3) {
                        case 1 :
                            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:11: COND_OP condArgs
                            {
                            COND_OP28=(Token)match(input,COND_OP,FOLLOW_COND_OP_in_subj647); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_COND_OP.add(COND_OP28);


                            pushFollow(FOLLOW_condArgs_in_subj649);
                            condArgs29=condArgs();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_condArgs.add(condArgs29.getTree());

                            }
                            break;

                    }


                    // AST REWRITE
                    // elements: condArgs, ID
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 97:30: -> ^( SUBJECT ID ( condArgs )? )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:33: ^( SUBJECT ID ( condArgs )? )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(SUBJECT, "SUBJECT")
                        , root_1);

                        adaptor.addChild(root_1, 
                        stream_ID.nextNode()
                        );

                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:97:46: ( condArgs )?
                        if ( stream_condArgs.hasNext() ) {
                            adaptor.addChild(root_1, stream_condArgs.nextTree());

                        }
                        stream_condArgs.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:98:4: '(' subj ')'
                    {
                    char_literal30=(Token)match(input,25,FOLLOW_25_in_subj667); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_25.add(char_literal30);


                    pushFollow(FOLLOW_subj_in_subj669);
                    subj31=subj();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_subj.add(subj31.getTree());

                    char_literal32=(Token)match(input,26,FOLLOW_26_in_subj671); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_26.add(char_literal32);


                    // AST REWRITE
                    // elements: subj
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 98:17: -> subj
                    {
                        adaptor.addChild(root_0, stream_subj.nextTree());

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "subj"


    public static class condArgs_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "condArgs"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:101:1: condArgs options {backtrack=true; memoize=true; } : ( cond | '(' ! cond ( ',' ! cond )* ')' !);
    public final LocStatParser.condArgs_return condArgs() throws RecognitionException {
        LocStatParser.condArgs_return retval = new LocStatParser.condArgs_return();
        retval.start = input.LT(1);

        int condArgs_StartIndex = input.index();

        LocStatAST root_0 = null;

        Token char_literal34=null;
        Token char_literal36=null;
        Token char_literal38=null;
        LocStatParser.cond_return cond33 =null;

        LocStatParser.cond_return cond35 =null;

        LocStatParser.cond_return cond37 =null;


        LocStatAST char_literal34_tree=null;
        LocStatAST char_literal36_tree=null;
        LocStatAST char_literal38_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:103:2: ( cond | '(' ! cond ( ',' ! cond )* ')' !)
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==ID||LA6_0==29) ) {
                alt6=1;
            }
            else if ( (LA6_0==25) ) {
                int LA6_2 = input.LA(2);

                if ( (synpred1_LocStat()) ) {
                    alt6=1;
                }
                else if ( (true) ) {
                    alt6=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 6, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }
            switch (alt6) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:103:4: cond
                    {
                    root_0 = (LocStatAST)adaptor.nil();


                    pushFollow(FOLLOW_cond_in_condArgs698);
                    cond33=cond();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cond33.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:104:4: '(' ! cond ( ',' ! cond )* ')' !
                    {
                    root_0 = (LocStatAST)adaptor.nil();


                    char_literal34=(Token)match(input,25,FOLLOW_25_in_condArgs703); if (state.failed) return retval;

                    pushFollow(FOLLOW_cond_in_condArgs706);
                    cond35=cond();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cond35.getTree());

                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:104:14: ( ',' ! cond )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( (LA5_0==27) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:104:15: ',' ! cond
                    	    {
                    	    char_literal36=(Token)match(input,27,FOLLOW_27_in_condArgs709); if (state.failed) return retval;

                    	    pushFollow(FOLLOW_cond_in_condArgs712);
                    	    cond37=cond();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, cond37.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);


                    char_literal38=(Token)match(input,26,FOLLOW_26_in_condArgs716); if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 9, condArgs_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "condArgs"


    public static class cond_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "cond"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:107:1: cond options {backtrack=true; memoize=true; } : ( numCond NOT -> ^( COND NOT numCond ) | numCond | '{' STRING '}' -> ^( COND SCRIPT STRING ) | ID NOT -> ^( COND NOT ^( SUBJECT ID ) ) | ID -> ^( COND COND_DEFAULT ^( SUBJECT ID ) ) );
    public final LocStatParser.cond_return cond() throws RecognitionException {
        LocStatParser.cond_return retval = new LocStatParser.cond_return();
        retval.start = input.LT(1);

        int cond_StartIndex = input.index();

        LocStatAST root_0 = null;

        Token NOT40=null;
        Token char_literal42=null;
        Token STRING43=null;
        Token char_literal44=null;
        Token ID45=null;
        Token NOT46=null;
        Token ID47=null;
        LocStatParser.numCond_return numCond39 =null;

        LocStatParser.numCond_return numCond41 =null;


        LocStatAST NOT40_tree=null;
        LocStatAST char_literal42_tree=null;
        LocStatAST STRING43_tree=null;
        LocStatAST char_literal44_tree=null;
        LocStatAST ID45_tree=null;
        LocStatAST NOT46_tree=null;
        LocStatAST ID47_tree=null;
        RewriteRuleTokenStream stream_30=new RewriteRuleTokenStream(adaptor,"token 30");
        RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_STRING=new RewriteRuleTokenStream(adaptor,"token STRING");
        RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
        RewriteRuleSubtreeStream stream_numCond=new RewriteRuleSubtreeStream(adaptor,"rule numCond");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:109:2: ( numCond NOT -> ^( COND NOT numCond ) | numCond | '{' STRING '}' -> ^( COND SCRIPT STRING ) | ID NOT -> ^( COND NOT ^( SUBJECT ID ) ) | ID -> ^( COND COND_DEFAULT ^( SUBJECT ID ) ) )
            int alt7=5;
            switch ( input.LA(1) ) {
            case ID:
                {
                int LA7_1 = input.LA(2);

                if ( (synpred2_LocStat()) ) {
                    alt7=1;
                }
                else if ( (synpred3_LocStat()) ) {
                    alt7=2;
                }
                else if ( (synpred5_LocStat()) ) {
                    alt7=4;
                }
                else if ( (true) ) {
                    alt7=5;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 1, input);

                    throw nvae;

                }
                }
                break;
            case 25:
                {
                int LA7_2 = input.LA(2);

                if ( (synpred2_LocStat()) ) {
                    alt7=1;
                }
                else if ( (synpred3_LocStat()) ) {
                    alt7=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 7, 2, input);

                    throw nvae;

                }
                }
                break;
            case 29:
                {
                alt7=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:109:4: numCond NOT
                    {
                    pushFollow(FOLLOW_numCond_in_cond740);
                    numCond39=numCond();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_numCond.add(numCond39.getTree());

                    NOT40=(Token)match(input,NOT,FOLLOW_NOT_in_cond742); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_NOT.add(NOT40);


                    // AST REWRITE
                    // elements: NOT, numCond
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 109:16: -> ^( COND NOT numCond )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:109:19: ^( COND NOT numCond )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(COND, "COND")
                        , root_1);

                        adaptor.addChild(root_1, 
                        stream_NOT.nextNode()
                        );

                        adaptor.addChild(root_1, stream_numCond.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:110:4: numCond
                    {
                    root_0 = (LocStatAST)adaptor.nil();


                    pushFollow(FOLLOW_numCond_in_cond757);
                    numCond41=numCond();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numCond41.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:111:4: '{' STRING '}'
                    {
                    char_literal42=(Token)match(input,29,FOLLOW_29_in_cond762); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_29.add(char_literal42);


                    STRING43=(Token)match(input,STRING,FOLLOW_STRING_in_cond764); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_STRING.add(STRING43);


                    char_literal44=(Token)match(input,30,FOLLOW_30_in_cond766); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_30.add(char_literal44);


                    // AST REWRITE
                    // elements: STRING
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 111:19: -> ^( COND SCRIPT STRING )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:111:22: ^( COND SCRIPT STRING )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(COND, "COND")
                        , root_1);

                        adaptor.addChild(root_1, 
                        (LocStatAST)adaptor.create(SCRIPT, "SCRIPT")
                        );

                        adaptor.addChild(root_1, 
                        stream_STRING.nextNode()
                        );

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 4 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:112:4: ID NOT
                    {
                    ID45=(Token)match(input,ID,FOLLOW_ID_in_cond781); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ID.add(ID45);


                    NOT46=(Token)match(input,NOT,FOLLOW_NOT_in_cond783); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_NOT.add(NOT46);


                    // AST REWRITE
                    // elements: NOT, ID
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 112:11: -> ^( COND NOT ^( SUBJECT ID ) )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:112:14: ^( COND NOT ^( SUBJECT ID ) )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(COND, "COND")
                        , root_1);

                        adaptor.addChild(root_1, 
                        stream_NOT.nextNode()
                        );

                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:112:25: ^( SUBJECT ID )
                        {
                        LocStatAST root_2 = (LocStatAST)adaptor.nil();
                        root_2 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(SUBJECT, "SUBJECT")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_ID.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 5 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:113:4: ID
                    {
                    ID47=(Token)match(input,ID,FOLLOW_ID_in_cond802); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ID.add(ID47);


                    // AST REWRITE
                    // elements: ID
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 113:7: -> ^( COND COND_DEFAULT ^( SUBJECT ID ) )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:113:10: ^( COND COND_DEFAULT ^( SUBJECT ID ) )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(COND, "COND")
                        , root_1);

                        adaptor.addChild(root_1, 
                        (LocStatAST)adaptor.create(COND_DEFAULT, "COND_DEFAULT")
                        );

                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:113:30: ^( SUBJECT ID )
                        {
                        LocStatAST root_2 = (LocStatAST)adaptor.nil();
                        root_2 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(SUBJECT, "SUBJECT")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_ID.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 10, cond_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "cond"


    public static class numCond_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "numCond"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:116:1: numCond options {backtrack=true; memoize=true; } : ( subj numOp -> ^( COND numOp subj ) | '(' numCond ')' -> numCond );
    public final LocStatParser.numCond_return numCond() throws RecognitionException {
        LocStatParser.numCond_return retval = new LocStatParser.numCond_return();
        retval.start = input.LT(1);

        int numCond_StartIndex = input.index();

        LocStatAST root_0 = null;

        Token char_literal50=null;
        Token char_literal52=null;
        LocStatParser.subj_return subj48 =null;

        LocStatParser.numOp_return numOp49 =null;

        LocStatParser.numCond_return numCond51 =null;


        LocStatAST char_literal50_tree=null;
        LocStatAST char_literal52_tree=null;
        RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
        RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
        RewriteRuleSubtreeStream stream_numCond=new RewriteRuleSubtreeStream(adaptor,"rule numCond");
        RewriteRuleSubtreeStream stream_subj=new RewriteRuleSubtreeStream(adaptor,"rule subj");
        RewriteRuleSubtreeStream stream_numOp=new RewriteRuleSubtreeStream(adaptor,"rule numOp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; }

            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:118:2: ( subj numOp -> ^( COND numOp subj ) | '(' numCond ')' -> numCond )
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==ID) ) {
                alt8=1;
            }
            else if ( (LA8_0==25) ) {
                int LA8_2 = input.LA(2);

                if ( (synpred6_LocStat()) ) {
                    alt8=1;
                }
                else if ( (true) ) {
                    alt8=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 8, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;

            }
            switch (alt8) {
                case 1 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:118:4: subj numOp
                    {
                    pushFollow(FOLLOW_subj_in_numCond839);
                    subj48=subj();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_subj.add(subj48.getTree());

                    pushFollow(FOLLOW_numOp_in_numCond841);
                    numOp49=numOp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_numOp.add(numOp49.getTree());

                    // AST REWRITE
                    // elements: subj, numOp
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 118:15: -> ^( COND numOp subj )
                    {
                        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:118:18: ^( COND numOp subj )
                        {
                        LocStatAST root_1 = (LocStatAST)adaptor.nil();
                        root_1 = (LocStatAST)adaptor.becomeRoot(
                        (LocStatAST)adaptor.create(COND, "COND")
                        , root_1);

                        adaptor.addChild(root_1, stream_numOp.nextTree());

                        adaptor.addChild(root_1, stream_subj.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:119:4: '(' numCond ')'
                    {
                    char_literal50=(Token)match(input,25,FOLLOW_25_in_numCond856); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_25.add(char_literal50);


                    pushFollow(FOLLOW_numCond_in_numCond858);
                    numCond51=numCond();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_numCond.add(numCond51.getTree());

                    char_literal52=(Token)match(input,26,FOLLOW_26_in_numCond860); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_26.add(char_literal52);


                    // AST REWRITE
                    // elements: numCond
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (LocStatAST)adaptor.nil();
                    // 119:20: -> numCond
                    {
                        adaptor.addChild(root_0, stream_numCond.nextTree());

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 11, numCond_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "numCond"


    public static class numOp_return extends ParserRuleReturnScope {
        LocStatAST tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "numOp"
    // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:122:1: numOp : ( ONE_OR_MORE | EXACTLY_ONE );
    public final LocStatParser.numOp_return numOp() throws RecognitionException {
        LocStatParser.numOp_return retval = new LocStatParser.numOp_return();
        retval.start = input.LT(1);


        LocStatAST root_0 = null;

        Token set53=null;

        LocStatAST set53_tree=null;

        try {
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:123:2: ( ONE_OR_MORE | EXACTLY_ONE )
            // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:
            {
            root_0 = (LocStatAST)adaptor.nil();


            set53=(Token)input.LT(1);

            if ( input.LA(1)==EXACTLY_ONE||input.LA(1)==ONE_OR_MORE ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (LocStatAST)adaptor.create(set53)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (LocStatAST)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (LocStatAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "numOp"

    // $ANTLR start synpred1_LocStat
    public final void synpred1_LocStat_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:103:4: ( cond )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:103:4: cond
        {
        pushFollow(FOLLOW_cond_in_synpred1_LocStat698);
        cond();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred1_LocStat

    // $ANTLR start synpred2_LocStat
    public final void synpred2_LocStat_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:109:4: ( numCond NOT )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:109:4: numCond NOT
        {
        pushFollow(FOLLOW_numCond_in_synpred2_LocStat740);
        numCond();

        state._fsp--;
        if (state.failed) return ;

        match(input,NOT,FOLLOW_NOT_in_synpred2_LocStat742); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred2_LocStat

    // $ANTLR start synpred3_LocStat
    public final void synpred3_LocStat_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:110:4: ( numCond )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:110:4: numCond
        {
        pushFollow(FOLLOW_numCond_in_synpred3_LocStat757);
        numCond();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred3_LocStat

    // $ANTLR start synpred5_LocStat
    public final void synpred5_LocStat_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:112:4: ( ID NOT )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:112:4: ID NOT
        {
        match(input,ID,FOLLOW_ID_in_synpred5_LocStat781); if (state.failed) return ;

        match(input,NOT,FOLLOW_NOT_in_synpred5_LocStat783); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred5_LocStat

    // $ANTLR start synpred6_LocStat
    public final void synpred6_LocStat_fragment() throws RecognitionException {
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:118:4: ( subj numOp )
        // C:\\Users\\Charles\\Documents\\ANTLR\\LocalizationScript\\LocStat.g:118:4: subj numOp
        {
        pushFollow(FOLLOW_subj_in_synpred6_LocStat839);
        subj();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_numOp_in_synpred6_LocStat841);
        numOp();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred6_LocStat

    // Delegated rules

    public final boolean synpred5_LocStat() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred5_LocStat_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred6_LocStat() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred6_LocStat_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred3_LocStat() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred3_LocStat_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred2_LocStat() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred2_LocStat_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred1_LocStat() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred1_LocStat_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


 

    public static final BitSet FOLLOW_stat_in_start460 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_EOF_in_start463 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_in_stat473 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_DEFINE_in_stat475 = new BitSet(new long[]{0x000000000000C880L});
    public static final BitSet FOLLOW_count_in_stat479 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_fraction_in_stat481 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_mean_in_stat483 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_med_in_stat485 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_28_in_stat488 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COUNT_in_count501 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_25_in_count503 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_subj_in_count505 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_count507 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FRACTION_in_fraction527 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_25_in_fraction529 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_subj_in_fraction533 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_27_in_fraction535 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_subj_in_fraction539 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_fraction541 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MEAN_in_mean563 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_25_in_mean565 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_scopedSubj_in_mean567 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_mean569 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MEDIAN_in_med588 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_25_in_med590 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_scopedSubj_in_med592 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_med594 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subj_in_scopedSubj616 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_SCOPE_OP_in_scopedSubj618 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_subj_in_scopedSubj622 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_subj644 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_COND_OP_in_subj647 = new BitSet(new long[]{0x0000000022002000L});
    public static final BitSet FOLLOW_condArgs_in_subj649 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_subj667 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_subj_in_subj669 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_subj671 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cond_in_condArgs698 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_condArgs703 = new BitSet(new long[]{0x0000000022002000L});
    public static final BitSet FOLLOW_cond_in_condArgs706 = new BitSet(new long[]{0x000000000C000000L});
    public static final BitSet FOLLOW_27_in_condArgs709 = new BitSet(new long[]{0x0000000022002000L});
    public static final BitSet FOLLOW_cond_in_condArgs712 = new BitSet(new long[]{0x000000000C000000L});
    public static final BitSet FOLLOW_26_in_condArgs716 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numCond_in_cond740 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_NOT_in_cond742 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numCond_in_cond757 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_29_in_cond762 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_STRING_in_cond764 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_cond766 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_cond781 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_NOT_in_cond783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_cond802 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subj_in_numCond839 = new BitSet(new long[]{0x0000000000040400L});
    public static final BitSet FOLLOW_numOp_in_numCond841 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_numCond856 = new BitSet(new long[]{0x0000000002002000L});
    public static final BitSet FOLLOW_numCond_in_numCond858 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_numCond860 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cond_in_synpred1_LocStat698 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numCond_in_synpred2_LocStat740 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_NOT_in_synpred2_LocStat742 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numCond_in_synpred3_LocStat757 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_synpred5_LocStat781 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_NOT_in_synpred5_LocStat783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_subj_in_synpred6_LocStat839 = new BitSet(new long[]{0x0000000000040400L});
    public static final BitSet FOLLOW_numOp_in_synpred6_LocStat841 = new BitSet(new long[]{0x0000000000000002L});

}